﻿<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">

<head>
<title xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory">第4章. 上下文与上下文分区</title>
<link rel="stylesheet" href="css/espertech.css" type="text/css">
	<meta xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" name="generator" content="DocBook XSL-NS Stylesheets V1.74.0">
		<meta xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" http-equiv="Content-Type" content="text/html; charset=UTF-8">
			<link rel="home" href="index.html" title="Esper参考文档">
				<link rel="up" href="index.html" title="Esper参考文档">
					<link rel="prev" href="event_representation.html" title="第3章. 事件表示">
						<link rel="next" href="epl_clauses.html" title="第5章. EPL参考：子句">
</head>

<body>
	<p xmlns:d="http://docbook.org/ns/docbook" id="title">
		<a href="./index.html" class="site_href"><strong>www.espertech.com</strong></a> <a href="http://www.espertech.com/esper/esper-documentation/" class="doc_href"><strong>文档</strong></a>
	</p>
	<ul xmlns:d="http://docbook.org/ns/docbook" class="docnav">
		<li class="previous"><a accesskey="p" href="event_representation.html"><strong>上一页</strong></a></li>
		<li class="next"><a accesskey="n" href="epl_clauses.html"><strong>下一页</strong></a></li>
	</ul>
	<div class="chapter" lang="en-US">
		<div class="titlepage">
			<div>
				<div>
					<h2 class="title"><a id="context"></a>第4章 上下文与上下文分区</h2>
				</div>
			</div>
		</div>
		<div class="toc">
			<dl>
				<dt><span class="sect1"><a href="context.html#context_intro">4.1. 概述</a></span></dt>
				<dt><span class="sect1"><a href="context.html#context_decl">4.2. 上下文声明</a></span></dt>
				<dd>
					<dl>
						<dt><span class="sect2"><a href="context.html#context_decl_props">4.2.1. 上下文提供的属性</a></span></dt>
						<dt><span class="sect2"><a href="context.html#context_def_keyed">4.2.2. 键控分段上下文</a></span></dt>
						<dt><span class="sect2"><a href="context.html#context_def_hashed">4.2.3. 哈希分段上下文</a></span></dt>
						<dt><span class="sect2"><a href="context.html#context_def_category">4.2.4. 类别分段上下文</a></span></dt>
						<dt><span class="sect2"><a href="context.html#context_def_nonoverlapping">4.2.5. 非重叠上下文</a></span></dt>
						<dt><span class="sect2"><a href="context.html#context_def_overlapping">4.2.6. 重叠上下文</a></span></dt>
						<dt><span class="sect2"><a href="context.html#context_def_condition">4.2.7. 上下文条件</a></span></dt>
					</dl>
				</dd>
				<dt><span class="sect1"><a href="context.html#context_nesting">4.3. 上下文嵌套</a></span></dt>
				<dd>
					<dl>
						<dt><span class="sect2"><a href="context.html#context_nesting_walkthru">4.3.1. 嵌套上下文示例详解</a></span></dt>
						<dt><span class="sect2"><a href="context.html#context_nesting_builtin">4.3.2. 内置嵌套上下文属性</a></span></dt>
					</dl>
				</dd>
				<dt><span class="sect1"><a href="context.html#context_other">4.4. 无上下文声明的分区</a></span></dt>
				<dt><span class="sect1"><a href="context.html#context_outputinitiated">4.5. 上下文分区启动时输出（非重叠上下文）或初始化时输出（重叠上下文）</a></span></dt>
				<dt><span class="sect1"><a href="context.html#context_outputterminated">4.6. 上下文分区结束时输出（非重叠上下文）或终止时输出（重叠上下文）</a></span></dt>
				<dt><span class="sect1"><a href="context.html#context_named_windows">4.7. 上下文与命名窗口</a></span></dt>
				<dt><span class="sect1"><a href="context.html#context_tables">4.8. 上下文与表</a></span></dt>
				<dt><span class="sect1"><a href="context.html#context_variables">4.9. 上下文与变量</a></span></dt>
				<dt><span class="sect1"><a href="context.html#context_selection">4.10. 特定上下文分区操作</a></span></dt>
			</dl>
		</div>
		<div class="sect1" lang="zh-CN">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="context_intro"></a>4.1. 概述</h2>
					</div>
				</div>
			</div>
			<p>本节讨论上下文的概念及其在事件处理语言(EPL)中的作用。</p>
			<p>
				当你在字典中查找<span class="emphasis"><em>上下文</em></span>这个词时，可能会发现：上下文是围绕特定事件、情况等的一组环境或事实。
			</p>
			<p>上下文相关的事件处理经常发生：例如，考虑一个监控银行交易的需求。对于不同的客户，您的分析需要考虑客户特定的聚合、模式或数据窗口。在这个例子中，检测的上下文就是客户。对于给定的客户，您可能希望通过使用聚合、数据窗口、模式以及其他EPL构造来分析该客户的银行交易。</p>
			<p>第二个例子考虑交通监控以检测超速违规。假设限速仅在上午9点到下午5点之间强制执行。检测的上下文具有时间性质。</p>
			<p>
				上下文将事件云分类为一个或多个集合。这些集合称为<span class="emphasis"><em>上下文分区</em></span>。与上下文关联的事件处理操作独立地对这些上下文分区中的每一个进行操作。(来源：取自Opher Etzion和Peter Niblett的《事件处理实战》一书)基本分区语句已在<a class="xref" href="processingmodel.html#processingmodel_basicpartition" title="2.11. 基本分区语句">第2.11节"基本分区语句"</a>中进行了回顾。
			</p>
			<p>上下文是维度的声明，因此可能产生一个或多个上下文分区。在银行交易示例中，上下文维度是客户，每个客户存在一个上下文分区。在交通监控示例中，存在一个仅在上午9点到下午5点之间存在的单一上下文分区，在该时间段之外不存在。</p>
			<p>
				在事件处理术语中，您可能会遇到<span class="emphasis"><em>事件处理代理</em></span>这个术语。一个语句就是一个<span class="emphasis"><em>事件处理代理</em></span>。上下文分区的另一个术语是<span class="emphasis"><em>事件处理代理实例</em></span>。
			</p>
			<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="tip">
				<h2>提示</h2>
				<p>将上下文分区视为类的实例，其中类是语句。</p>
			</div>
			<p>EPL允许您显式声明上下文，提供以下优势：</p>
			<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="orderedlist">
				<ol>
					<li>
						<p>上下文可以应用于多个语句，从而消除在语句之间复制上下文维度信息的需要。</p>
					</li>
					<li>
						<p>上下文分区可以在时间上重叠。</p>
					</li>
					<li>
						<p>上下文分区提供独立于语句生命周期的细粒度生命周期，便于指定分析何时开始和结束。</p>
					</li>
					<li>
						<p>细粒度的锁粒度：运行时在上下文分区级别锁定，从而实现非常高的并发性，在哈希分段上下文下，单个语句的最大(理论)并行度为2^31-1(2,147,483,647)个并行线程。</p>
					</li>
					<li>
						<p>EPL可能变得更易读，因为常见的谓词表达式可以被分解到上下文中。</p>
					</li>
					<li>
						<p>您可以指定由两个或多个上下文组成的嵌套上下文。特别是时间上下文类型经常与面向分段的上下文结合使用。</p>
					</li>
					<li>
						<p>使用上下文，您的应用程序可以在不保留内存中任何事件的情况下，在时间段(重叠或非重叠)内聚合事件。</p>
					</li>
					<li>
						<p>使用上下文，您的应用程序可以协调多个语句的边界。</p>
					</li>
				</ol>
			</div>
			<p>
				EPL允许您通过下面介绍的<code class="literal">create context</code>语法显式声明上下文。
			</p>
			<p>
				声明上下文后，一个或多个语句可以通过指定<code class="literal">context </code><span class="emphasis"><em>name</em></span>来引用该上下文。当语句引用上下文时，所有与EPL语句相关的状态(如聚合、模式或数据窗口等)每个上下文分区都存在一次。
			</p>
			<p>如果语句没有声明上下文，它隐式具有单个上下文分区。单个上下文分区的生命周期与语句的部署时间相同，在语句取消部署时结束。</p>
			<p>
				您可能听说过<span class="emphasis"><em>会话</em></span>这个术语。上下文分区与会话相同。
			</p>
			<p>
				您可能听说过<span class="emphasis"><em>会话窗口</em></span>这个术语，用于描述从会话变为活动状态到会话被销毁之间的持续时间。我们使用上下文分区生命周期这个术语代替。
			</p>
			<p>上下文声明指定运行时如何管理上下文分区(或会话)：</p>
			<div class="itemizedlist">
				<ul compact="compact">
					<li>
						<p>
							对于键控分段上下文，每个键或多个键有一个上下文分区(或会话)，参见<a class="xref" href="context.html#context_def_keyed" title="4.2.2. 键控分段上下文">第4.2.2节"键控分段上下文"</a>。
						</p>
					</li>
					<li>
						<p>
							对于哈希分段上下文，每个键或多个键的哈希码有一个上下文分区(或会话)，参见<a class="xref" href="context.html#context_def_hashed" title="4.2.3. 哈希分段上下文">第4.2.3节"哈希分段上下文"</a>。
						</p>
					</li>
					<li>
						<p>
							对于重叠上下文，可以有多个重叠的上下文分区(或会话)，参见<a class="xref" href="context.html#context_def_overlapping" title="4.2.6. 重叠上下文">第4.2.6节"重叠上下文"</a>。
						</p>
					</li>
					<li>
						<p>
							对于非重叠上下文，只有零个或一个上下文分区(或会话)，参见<a class="xref" href="context.html#context_def_nonoverlapping" title="4.2.5. 非重叠上下文">第4.2.5节"非重叠上下文"</a>。
						</p>
					</li>
					<li>
						<p>
							对于类别分段上下文，每个预定义类别有一个上下文分区(或会话)，参见<a class="xref" href="context.html#context_def_category" title="4.2.4. 类别分段上下文">第4.2.4节"类别分段上下文"</a>。
						</p>
					</li>
				</ul>
			</div>
			<p>
				有关管理上下文分区的API，请参见<a class="xref" href="apiruntime.html#apiruntime-contextpartitionadmin" title="16.17. 上下文分区管理">第16.17节"上下文分区管理"</a>。有关锁定和线程的更多信息，请参见<a class="xref" href="apiruntime.html#apiruntime-threading" title="16.8. 运行时线程和并发">第16.8节"运行时线程和并发"</a>。有关性能相关信息，请参考<a class="xref" href="performance.html" title="第24章. 性能">第24章<i>性能</i></a>。
			</p>
		</div>
		<div class="sect1" lang="zh-CN">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="context_decl"></a>4.2. 上下文声明</h2>
					</div>
				</div>
			</div>
			<p>
				<code class="literal">create context</code>语句通过指定上下文名称和上下文维度信息来声明上下文。
			</p>
			<p>上下文声明本身不消耗任何资源或执行任何逻辑，直到您的应用程序启动至少一个引用该上下文的语句。在此之前，上下文处于非活动状态且未被使用。</p>
			<p>当您的应用程序部署第一个引用上下文的语句时，运行时激活该上下文。</p>
			<p>一旦您的应用程序取消部署所有引用上下文的语句，上下文再次变为非活动状态。</p>
			<p>当您的应用程序取消部署引用上下文的语句时，与该语句关联的上下文分区也会结束(与其他已部署语句关联的上下文分区继续存在)。</p>
			<p>为了使您的应用程序能够取消部署声明上下文的语句，它还必须取消部署任何引用该上下文的语句。</p>
			<p>当您的应用程序取消部署所有引用该上下文的语句并取消部署声明上下文的语句时，运行时完全删除上下文声明。</p>
			<p>
				<code class="literal">create context</code>语句不会向监听器或订阅者发布任何输出事件，并且在迭代时不会返回任何行。
			</p>
			<div class="sect2" lang="zh-CN">
				<div class="titlepage">
					<div>
						<div>
							<h3 class="title"><a id="context_decl_props"></a>4.2.1. 上下文提供的属性</h3>
						</div>
					</div>
				</div>
				<p>每个上下文声明都提供一组内置上下文属性以及适用的起始事件或模式属性。您可以选择这些上下文属性进行输出或在任何语句表达式中使用它们。</p>
				<p>
					引用内置上下文属性为<code class="literal">context.</code><span class="emphasis"><em>property_name</em></span>，其中<span class="emphasis"><em>property_name</em></span>指内置上下文属性的名称。
				</p>
				<p>
					引用起始事件或模式匹配事件属性为<code class="literal">context.</code><span class="emphasis"><em>stream_name</em></span>.<span class="emphasis"><em>property_name</em></span>，其中<span class="emphasis"><em>stream_name</em></span>指分配给事件的名称或模式中指定的标签名称，<span class="emphasis"><em>property_name</em></span>指起始事件或模式匹配事件属性的名称。
				</p>
			</div>
			<div class="sect2" lang="zh-CN">
				<div class="titlepage">
					<div>
						<div>
							<h3 class="title"><a id="context_def_keyed"></a>4.2.2. 键控分段上下文</h3>
						</div>
					</div>
				</div>
				<p>此上下文根据一个或多个事件属性的值将事件分配给上下文分区，使用这些属性的值作为直接选择唯一上下文分区的键。因此，每个事件属于恰好一个上下文分区或零个上下文分区(仅当事件不匹配可选的过滤器谓词表达式时为零个上下文分区)。每个上下文分区处理一个键值(键值可以是复合键)。</p>
				<p>创建键控分段上下文的语法是：</p>
				<pre class="synopsis">create context <span class="emphasis"><em>context_name</em></span> partition [by] <span class="emphasis"><em>partition_def</em></span>
  [initiated [by] <span class="emphasis"><em>initiated_def</em></span>] 
  [terminated [by] <span class="emphasis"><em>terminating_condition</em></span>]</pre>
				<p>
					您分配给上下文的<span class="emphasis"><em>context_name</em></span>可以是任何标识符。
				</p>
				<p>
					在上下文名称之后是<code class="literal">partition</code>关键字和<span class="emphasis"><em>partition_def</em></span>分区定义，该定义列出提供分区键值(或复合键的值)的事件属性和事件类型。
				</p>
				<p>
					您可以选择使用<code class="literal">initiated</code>关键字声明起始事件，并且可以为终止分区提供终止条件。
				</p>
				<div class="sect3" lang="zh-CN">
					<div class="titlepage">
						<div>
							<div>
								<h4 class="title"><a id="context_def_keyed_partition"></a>4.2.2.1. 分区依据</h4>
							</div>
						</div>
					</div>
					<p>
						在<code class="literal">partitioned by</code>之后，您可以列出提供标识唯一分区的键值的事件属性。概要如下：
					</p>
					<pre class="synopsis">create context <span class="emphasis"><em>context_name</em></span> partition [by]
  <span class="emphasis"><em>event_property</em></span> [and <span class="emphasis"><em>event_property</em></span> [and ...]] from <span class="emphasis"><em>stream_def</em></span> [ [as] <span class="emphasis"><em>stream_name</em></span>]
  [, <span class="emphasis"><em>event_property</em></span> [...] from <span class="emphasis"><em>stream_def</em></span>]   [, ...]</pre>
					<p>
						<span class="emphasis"><em>event_property</em></span>是提供选择唯一分区的值的事件属性名称。多个事件属性名称用<code class="literal">and</code>关键字或逗号分隔。有关键表达式的更多详细信息，请参见<a class="xref" href="epl_clauses.html#epl-syntax-compositekey" title="5.2.13. 复合键和数组值作为键">第5.2.13节"复合键和数组值作为键"</a>。
					</p>
					<p>
						<span class="emphasis"><em>stream_def</em></span>是流定义，由事件类型名称组成，可选地后跟包含过滤器表达式的括号。如果提供过滤器表达式，则只有匹配该事件类型的提供的过滤器表达式的事件才会被上下文分区考虑。不允许使用命名窗口或表的名称。
					</p>
					<p>您可以为每个流定义列出多个事件属性。您可以列出多个流定义。在指定多个事件属性和/或多个流定义时，请参考下面的使用指南。</p>
					<p>
						您可以指定可选的<code class="literal">as</code>关键字和流名称。这指示运行时使分区的第一个事件在上下文内置属性中可用，并在<code class="literal">terminated by</code>中进行匹配。您可以在<code class="literal">partition by</code>或<code class="literal">initiated by</code>中指定流名称，但不能同时在两者中指定。
					</p>
					<p>
						下一个语句创建一个上下文<code class="literal">SegmentedByCustomer</code>，该上下文考虑<code class="literal">BankTxn</code>事件类型的<code class="literal">custId</code>属性的值来选择要分配事件的上下文分区：
					</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context SegmentedByCustomer partition by custId from BankTxn</pre>
					<p>以下语句引用上面创建的上下文，计算每个客户的每个账户的总取款金额：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context SegmentedByCustomer
select custId, account, sum(amount) from BankTxn group by account</pre>
					<p>以下语句引用上面创建的上下文，检测同一客户在第一次取款超过400后10分钟内发生的第二次超过400的取款：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context SegmentedByCustomer
select * from pattern [
  every a=BankTxn(amount&gt;400) -&gt; b=BankTxn(amount&gt;400) where timer:within(10 minutes)
]</pre>
					<p>引用键控分段上下文的语句必须在语句的任何位置至少有一个过滤器表达式，用于查找上下文声明中列出的任何事件类型的事件。</p>
					<p>例如，以下内容无效：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// LoginEvent和LogoutEvent都没有在上下文声明中列出
context SegmentedByCustomer
select * from pattern [every a=LoginEvent -&gt; b=LogoutEvent where timer:within(10 minutes)]</pre>
				</div>
				<div class="sect3" lang="zh-CN">
					<div class="titlepage">
						<div>
							<div>
								<h4 class="title"><a id="context_def_keyed_initiated"></a>4.2.2.2. 起始于</h4>
							</div>
						</div>
					</div>
					<p>
						当提供时，<code class="literal">initiated by</code>列出可以启动新分区的事件类型和过滤条件。概要如下：
					</p>
					<pre class="synopsis">initiated by <span class="emphasis"><em>stream_def</em></span> [ [as] <span class="emphasis"><em>stream_name</em></span>]
  [, <span class="emphasis"><em>stream_def</em></span> [ [as] <span class="emphasis"><em>stream_name</em></span>]]   [, ...]</pre>
					<p>
						当不提供<code class="literal">initiated by</code>时，<code class="literal">partitioned by</code>提供可以启动新分区的事件类型和过滤条件。
					</p>
					<p>
						<span class="emphasis"><em>stream_def</em></span>是流定义，由事件类型名称组成，可选地后跟包含过滤器表达式的括号。
					</p>
					<p>如果提供过滤器表达式，则只有匹配该事件类型的提供的过滤器表达式的事件才会启动新的上下文分区。不允许使用命名窗口或表的名称。</p>
					<p>
						您可以使用<code class="literal">as</code>关键字和流名称来命名起始事件。该事件在上下文内置属性中可用，并在<code class="literal">terminated by</code>中进行匹配。您可以在<code class="literal">partition by</code>或<code class="literal">initiated by</code>中指定流名称，但不能同时在两者中指定。
					</p>
					<p>这是一个示例上下文和语句：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context PerCustId_TriggeredByLargeAmount
  partition by custId from BankTxn 
  initiated by BankTxn(amount&gt;100) as largeTxn</pre>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context PerCustId_TriggeredByLargeAmount select context.largeTxn, custId, sum(amount) from BankTxn</pre>
					<p>
						当<code class="literal">BankTxn</code>事件到达且<code class="literal">amount</code>值大于100时，系统开始分析(分配分区)该<code class="literal">BankTxn</code>事件的特定<code class="literal">custId</code>值。该语句汇总了具有相同<code class="literal">custId</code>值的所有<code class="literal">BankTxn</code>事件的<code class="literal">amount</code>值(无论其金额如何)。示例将名称<code class="literal">largeTxn</code>分配给起始事件，并使用<code class="literal">context.largeTxn</code>选择该事件。
					</p>
				</div>
				<div class="sect3" lang="zh-CN">
					<div class="titlepage">
						<div>
							<div>
								<h4 class="title"><a id="context_def_keyed_terminated"></a>4.2.2.3. 终止条件</h4>
							</div>
						</div>
					</div>
					<p>
						当提供时，<code class="literal">terminated by</code>提供终止分区的条件。概要如下：
					</p>
					<pre class="synopsis">terminated [by] <span class="emphasis"><em>terminating_condition</em></span>
    </pre>
					<p>
						可能的条件列表在<a class="xref" href="context.html#context_def_condition" title="4.2.7. 上下文条件">第4.2.7节"上下文条件"</a>中提供。导致终止的事件不会同时分配新的分区。
					</p>
					<p>
						任何在终止条件和<code class="literal">partition by</code>中都列出的事件类型都会通过键隐式关联。
					</p>
					<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="note">
						<h2>注意</h2>
						<p>在终止条件和与上下文关联的语句查找相同事件的情况下，您可以使用@Priority来分配是首先处理上下文还是语句。</p>
					</div>
					<p>考虑以下两个语句：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context PerCustId_UntilExpired
  partition by custId from BankTxn 
  terminated by BankTxn(expired=true)</pre>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context PerCustId_UntilExpired select custId, sum(amount) from BankTxn output last when terminated</pre>
					<p>
						当<code class="literal">BankTxn</code>事件到达时，系统仅为该<code class="literal">BankTxn</code>事件的特定<code class="literal">custId</code>值开始分析(分配分区)。当具有相同<code class="literal">custId</code>值且<code class="literal">expired</code>值为<code class="literal">true</code>的<code class="literal">BankTxn</code>事件到达时，系统停止分析(丢弃分区)。由于语句指定了<code class="literal">output last when terminated</code>，输出在分析停止时发生。
					</p>
					<p>
						如果<code class="literal">initiated by</code>提供了流名称，终止条件可以与起始事件相关联。
					</p>
					<p>将终止事件与起始事件相关联的上下文是：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context PerCustId_TriggeredByLargeAmount_UntilExpired
  partition by custId from BankTxn 
  initiated by BankTxn(amount&gt;100) as txn
  terminated by BankTxn(expired=true and user=txn.user)</pre>
					<p>
						此示例定义了一个上下文，其中当到达<code class="literal">amount</code>值大于100的<code class="literal">BankTxn</code>事件(起始事件)时，系统开始分析。仅针对特定<code class="literal">custId</code>值的分析。当到达<code class="literal">expired</code>值为<code class="literal">true</code>且具有相同<code class="literal">custId</code>值且<code class="literal">user</code>值与起始事件的<code class="literal">user</code>值匹配的<code class="literal">BankTxn</code>事件时，停止分析。
					</p>
				</div>
				<div class="sect3" lang="zh-CN">
					<div class="titlepage">
						<div>
							<div>
								<h4 class="title"><a id="context_def_keyed_multitype"></a>4.2.2.4. 多流定义</h4>
							</div>
						</div>
					</div>
					<p>如果上下文声明列出多个流，每个事件类型必须不相关：您不能两次列出相同的事件类型，也不能列出已列出的任何事件类型的子类型或超类型。</p>
					<p>
						以下不是有效的声明，因为<code class="literal">BankTxn</code>事件类型被列出两次：
					</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 无效
create context SegmentedByCustomer partition by custId from BankTxn, account from BankTxn</pre>
					<p>如果上下文声明列出多个流，为每个事件类型提供的事件属性数量也必须相同。每个事件类型列出的事件属性返回的值类型必须在各自列出的位置匹配，即每个事件类型列出的第一个属性必须具有相同的类型，每个事件类型列出的第二个属性必须具有相同的类型，依此类推。</p>
					<p>
						以下不是有效的声明，因为<code class="literal">BankTxn</code>的客户ID和<code class="literal">LoginEvent</code>的登录时间不是相同类型：
					</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 无效：属性间类型不匹配
create context SegmentedByCustomer partition by custId from BankTxn, loginTime from LoginEvent</pre>
					<p>
						下一个语句创建一个上下文<code class="literal">SegmentedByCustomer</code>，该上下文还考虑<code class="literal">LoginEvent</code>和<code class="literal">LogoutEvent</code>：
					</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context SegmentedByCustomer partition by 
  custId from BankTxn, loginId from LoginEvent, loginId from LogoutEvent</pre>
					<p>
						如您可能已经注意到，上面的示例将<code class="literal">loginId</code>作为<code class="literal">LoginEvent</code>和<code class="literal">LogoutEvent</code>事件的事件属性名称。假设登录和注销事件的<code class="literal">loginId</code>事件属性具有相同的类型，并且携带与银行交易事件的<code class="literal">custId</code>完全相同的值，从而允许所有三种事件类型的事件应用于相同的客户特定上下文分区。
					</p>
				</div>
				<div class="sect3" lang="zh-CN">
					<div class="titlepage">
						<div>
							<div>
								<h4 class="title"><a id="context_def_keyed_comparefilters"></a>4.2.2.5. 比较过滤器条件的使用</h4>
							</div>
						</div>
					</div>
					<p>
						您可以为每个事件类型添加过滤器表达式。<code class="literal">partition by</code>中的过滤器条件适用于引用上下文的所有语句和相同事件类型。<code class="literal">initiated by</code>中的过滤器条件仅适用于起始事件。
					</p>
					<p>
						下面的语句汇总了每个<code class="literal">custId</code>的所有<code class="literal">BankTxn</code>事件的<code class="literal">amount</code>，仅针对那些<code class="literal">amount</code>大于100的<code class="literal">BankTxn</code>事件。
					</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context PerCust_AmountGreater100
  partition by custId from BankTxn(amount&gt;100)
  initiated by BankTxn</pre>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context PerCust_AmountGreater100 select custId, sum(amount) from BankTxn</pre>
					<p>
						下面的语句汇总了每个<code class="literal">custId</code>的所有<code class="literal">BankTxn</code>事件的<code class="literal">amount</code>，但仅当第一个到达的<code class="literal">BankTxn</code>事件的<code class="literal">amount</code>大于100时。
					</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context PerCust_TriggeredByLargeTxn
  partition by custId from BankTxn
  initiated by BankTxn(amount&gt;100)</pre>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context PerCust_TriggeredByLargeTxn select custId, sum(amount) from BankTxn</pre>
				</div>
				<div class="sect3" lang="zh-CN">
					<div class="titlepage">
						<div>
							<div>
								<h4 class="title"><a id="context_def_keyed_multiprop"></a>4.2.2.6. 每个事件类型的多个属性</h4>
							</div>
						</div>
					</div>
					<p>您可以根据两个或多个事件属性的值将事件分配给上下文分区。因此，运行时使用这些属性的值的组合来选择上下文分区。</p>
					<p>示例上下文声明如下：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context ByCustomerAndAccount partition by custId and account from BankTxn</pre>
					<p>下一个语句引用上下文并计算每个客户和账户的总取款金额：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context ByCustomerAndAccount select custId, account, sum(amount) from BankTxn</pre>
					<p>
						如您所见，上面的语句不需要指定<code class="literal">group by</code>子句来按客户和账户聚合，因为每个唯一的客户ID和账户组合的事件都被分配到单独的上下文分区。
					</p>
				</div>
				<div class="sect3" lang="zh-CN">
					<div class="titlepage">
						<div>
							<div>
								<h4 class="title"><a id="context_def_keyed_builtin"></a>4.2.2.7. 内置上下文属性</h4>
							</div>
						</div>
					</div>
					<p>当您的语句引用键控分段上下文时，以下上下文属性可用：</p>
					<div class="table">
						<a id="d0e4394"></a>
						<p class="title">
							<b>表4.1. 键控分段上下文属性</b>
						</p>
						<div class="table-contents">
							<table summary="键控分段上下文属性" border="1">
								<colgroup>
									<col>
										<col>
								</colgroup>
								<thead>
									<tr>
										<th>名称</th>
										<th>描述</th>
									</tr>
								</thead>
								<tbody>
									<tr>
										<td><code class="literal">name</code></td>
										<td>字符串类型的上下文名称。</td>
									</tr>
									<tr>
										<td><code class="literal">id</code></td>
										<td>运行时分配给上下文分区的整数类型内部上下文分区ID。</td>
									</tr>
									<tr>
										<td><code class="literal">key1</code></td>
										<td>第一个键的事件属性值。</td>
									</tr>
									<tr>
										<td><code class="literal">key</code><span class="emphasis"><em>N</em></span></td>
										<td>第N个键的事件属性值。</td>
									</tr>
									<tr>
										<td><span class="emphasis"><em>stream name</em></span> from <code class="literal">partitioned by</code> or <code class="literal">initiated by</code></td>
										<td>启动分区的事件。</td>
									</tr>
								</tbody>
							</table>
						</div>
					</div>
					<br class="table-break">
						<p>假设键控分段上下文声明如下：</p> <pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context ByCustomerAndAccount partition by custId and account from BankTxn</pre>
						<p>例如，您可以选择上下文属性如下：</p> <pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context ByCustomerAndAccount
  select context.name, context.id, context.key1, context.key2 from BankTxn</pre>
				</div>
				<div class="sect3" lang="zh-CN">
					<div class="titlepage">
						<div>
							<div>
								<h4 class="title"><a id="context_def_keyed_additional"></a>4.2.2.8. 连接示例</h4>
							</div>
						</div>
					</div>
					<p>本节讨论上下文对连接的影响，以提供更多的使用示例并加深对上下文分区的理解。</p>
					<p>考虑如下声明的上下文：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context ByCust partition by custId from BankTxn</pre>
					<p>以下语句在当前事件与最近30分钟的事件之间匹配，以确定那些金额匹配的事件，在同一客户ID内：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context ByCust 
  select * from BankTxn as t1 unidirectional, BankTxn#time(30) t2 
  where t1.amount = t2.amount</pre>
					<p>
						请注意，上面连接中的<code class="literal">where</code>子句没有提到客户ID。由于每个<code class="literal">BankTxn</code>应用于特定的上下文分区，连接在该单个上下文分区内评估。
					</p>
					<p>考虑下一个语句，该语句将安全事件与每个客户的最近30分钟的交易事件匹配：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context ByCust
  select * from SecurityEvent as t1 unidirectional, BankTxn#time(30) t2 
  where t1.customerName = t2.customerName</pre>
					<p>
						当安全事件到达时，它应用于所有上下文分区而不是任何特定的上下文分区，因为<code class="literal">SecurityEvent</code>事件类型不是上下文声明的一部分。
					</p>
				</div>
				<div class="sect2" lang="zh-CN">
					<div class="titlepage">
						<div>
							<div>
								<h3 class="title"><a id="context_def_hashed"></a>4.2.3. 哈希分段上下文</h3>
							</div>
						</div>
					</div>
					<p>此上下文根据哈希函数和模运算的结果将事件分配给上下文分区。每个事件属于恰好一个上下文分区或零个上下文分区(仅当事件不匹配可选的过滤器谓词表达式时为零个上下文分区)。每个上下文分区处理恰好一个哈希值模粒度。</p>
					<p>创建哈希分段上下文的语法如下：</p>
					<pre class="synopsis">create context <span class="emphasis"><em>context_name</em></span> coalesce [by] 
  <span class="emphasis"><em>hash_func_name</em></span>(<span class="emphasis"><em>hash_func_param</em></span>) from <span class="emphasis"><em>stream_def</em></span>
  [, <span class="emphasis"><em>hash_func_name</em></span>(<span class="emphasis"><em>hash_func_param</em></span>) from <span class="emphasis"><em>stream_def</em></span> ]
  [, ...]
  granularity <span class="emphasis"><em>granularity_value</em></span>
  [preallocate]</pre>
					<p>
						您分配给上下文的<span class="emphasis"><em>context_name</em></span>可以是任何标识符。
					</p>
					<p>
						在上下文名称之后是一个或多个哈希函数名称和参数对以及每个条目的流定义列表，用逗号(<code class="literal">,</code>)分隔。
					</p>
					<p>
						<span class="emphasis"><em>hash_func_name</em></span>可以是<code class="literal">consistent_hash_crc32</code>或<code class="literal">hash_code</code>或插件单行函数。<span class="emphasis"><em>hash_func_param</em></span>是参数表达式列表。
					</p>
					<div class="itemizedlist">
						<ul compact="compact">
							<li>
								<p>
									如果指定<code class="literal">consistent_hash_crc32</code>，运行时使用CRC-32算法计算一致的哈希码。
								</p>
							</li>
							<li>
								<p>
									如果指定<code class="literal">hash_code</code>，运行时使用Java对象哈希码。
								</p>
							</li>
							<li>
								<p>
									如果指定插件单行函数的名称，您的函数必须返回一个整数值作为哈希码。您可以在参数中使用通配符<code class="literal">(*)</code>将底层事件传递给单行函数。
								</p>
							</li>
						</ul>
					</div>
					<p>
						<span class="emphasis"><em>stream_def</em></span>是流定义，由事件类型名称组成，可选地后跟包含过滤器表达式的括号。如果提供过滤器表达式，则只有匹配该事件类型的提供的过滤器表达式的事件才会被上下文分区考虑。不允许使用命名窗口或表的名称。
					</p>
					<p>您可以列出多个流定义。在指定多个流定义时，请参考下面的使用指南。</p>
					<p>
						<code class="literal">granularity</code>是必需的，是一个整数，定义上下文分区的最大数量。运行时计算哈希码模粒度<code class="literal">hash(</code><span class="emphasis"><em>params</em></span><code class="literal">) mod </code><span class="emphasis"><em>granularity</em></span>以确定上下文分区。当您指定<code class="literal">hash_code</code>函数时，运行时使用对象哈希码，计算为<span class="emphasis"><em>params.</em></span><code class="literal">hashCode() %</code> <span class="emphasis"><em>granularity</em></span>。
					</p>
					<p>由于运行时在上下文分区级别锁定以保护状态，粒度定义了最大并行度。例如，粒度为1024意味着1024个上下文分区处理事件，因此最多1024个线程可以并发处理每个分配的语句。</p>
					<p>
						可选的<code class="literal">preallocate</code>关键字指示运行时在语句引用上下文时立即分配所有上下文分区。这对性能有益，因为运行时不需要确定是否存在上下文分区并动态分配，但可能需要更多内存。
					</p>
					<p>
						下一个语句创建一个上下文<code class="literal">SegmentedByCustomerHash</code>，该上下文考虑<code class="literal">BankTxn</code>事件类型的<code class="literal">custId</code>属性的CRC-32哈希码来选择要分配事件的上下文分区，最多16个不同的预分配上下文分区：
					</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context SegmentedByCustomerHash
  coalesce by consistent_hash_crc32(custId) from BankTxn granularity 16 preallocate</pre>
					<p>以下语句引用上面创建的上下文计算每个客户每个账户的总取款金额：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context SegmentedByCustomerHash
select custId, account, sum(amount) from BankTxn group by custId, account</pre>
					<p>
						请注意，上面的语句按<code class="literal">custId</code>分组：由于不同客户ID的事件可以分配到相同的上下文分区，因此语句还必须按客户ID分组。
					</p>
					<p>
						下一个上下文声明假设应用程序提供了一个<code class="literal">computeHash</code>单行函数，该函数接受BankTxn作为参数，其中此函数的结果必须是一个整数值，为每个事件返回上下文分区ID：
					</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context MyHashContext
  coalesce by computeHash(*) from BankTxn granularity 16 preallocate</pre>
					<p>引用哈希分段上下文的语句必须在语句的任何位置至少有一个过滤器表达式，用于查找上下文声明中列出的任何事件类型的事件。</p>
					<p>例如，以下内容无效：</p>
					<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// LoginEvent和LogoutEvent都没有在上下文声明中列出
context SegmentedByCustomerHash
select * from pattern [every a=LoginEvent -&gt; b=LogoutEvent where timer:within(10 minutes)]</pre>
					<div class="sect3" lang="zh-CN">
						<div class="titlepage">
							<div>
								<div>
									<h4 class="title"><a id="context_def_hashed_multitype"></a>4.2.3.1. 多流定义</h4>
								</div>
							</div>
						</div>
						<p>如果上下文声明列出多个流，每个事件类型必须不相关：您不能两次列出相同的事件类型，也不能列出已列出的任何事件类型的子类型或超类型。</p>
						<p>如果上下文声明列出多个流，哈希码函数应为所有流的相关键返回相同的哈希码。</p>
						<p>
							下一个语句创建一个上下文<code class="literal">HashedByCustomer</code>，该上下文还考虑<code class="literal">LoginEvent</code>和<code class="literal">LogoutEvent</code>：
						</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context HashedByCustomer as coalesce
  consistent_hash_crc32(custId) from BankTxn,
  consistent_hash_crc32(loginId) from LoginEvent, 
  consistent_hash_crc32(loginId) from LogoutEvent
  granularity 32 preallocate</pre>
					</div>
					<div class="sect3" lang="zh-CN">
						<div class="titlepage">
							<div>
								<div>
									<h4 class="title"><a id="context_def_hashed_filter"></a>4.2.3.2. 过滤器</h4>
								</div>
							</div>
						</div>
						<p>您可以为列出的每个事件类型添加过滤器表达式。运行时将过滤器表达式应用于引用上下文和相同事件类型的语句。</p>
						<p>
							下一个语句创建一个上下文<code class="literal">HashedByCustomer</code>，该上下文不考虑指示登录失败的登录事件。
						</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context HashedByCustomer 
  coalesce consistent_hash_crc32(loginId) from LoginEvent(failed = false) 
  granularity 1024 preallocate</pre>
					</div>
					<div class="sect3" lang="zh-CN">
						<div class="titlepage">
							<div>
								<div>
									<h4 class="title"><a id="context_def_hashed_builtin"></a>4.2.3.3. 内置上下文属性</h4>
								</div>
							</div>
						</div>
						<p>当您的语句引用键控分段上下文时，以下上下文属性可用：</p>
						<div class="table">
							<a id="d0e4670"></a>
							<p class="title">
								<b>表4.2. 哈希分段上下文属性</b>
							</p>
							<div class="table-contents">
								<table summary="哈希分段上下文属性" border="1">
									<colgroup>
										<col>
											<col>
									</colgroup>
									<thead>
										<tr>
											<th>名称</th>
											<th>描述</th>
										</tr>
									</thead>
									<tbody>
										<tr>
											<td><code class="literal">name</code></td>
											<td>字符串类型的上下文名称。</td>
										</tr>
										<tr>
											<td><code class="literal">id</code></td>
											<td>运行时分配给上下文分区的整数类型内部上下文分区ID。</td>
										</tr>
									</tbody>
								</table>
							</div>
						</div>
						<br class="table-break">
							<p>假设哈希分段上下文声明如下：</p> <pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context ByCustomerHash coalesce consistent_hash_crc32(custId) from BankTxn granularity 1024</pre>
							<p>例如，您可以选择上下文属性如下：</p> <pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context ByCustomerHash
  select context.name, context.id from BankTxn</pre>
					</div>
					<div class="sect3" lang="zh-CN">
						<div class="titlepage">
							<div>
								<div>
									<h4 class="title"><a id="context_def_hashed_perf"></a>4.2.3.4. 性能考虑</h4>
								</div>
							</div>
						</div>
						<p>
							基于Java对象哈希码的<code class="literal">hash_code</code>函数通常比CRC32算法更快。当使用非字符串参数或多个参数时，CRC32算法需要运行时将所有表达式结果序列化为字节数组以计算CRC32哈希码。
						</p>
						<p>
							当使用<code class="literal">preallocate</code>时，建议保持粒度较小(1k及以下)。
						</p>
						<p>
							当指定大于<code class="literal">65536</code>(64k)的粒度时，运行时切换到基于Map的上下文分区状态查找，这可能会减慢语句处理速度。
						</p>
					</div>
					<div class="sect2" lang="zh-CN">
						<div class="titlepage">
							<div>
								<div>
									<h3 class="title"><a id="context_def_category"></a>4.2.4. 类别分段上下文</h3>
								</div>
							</div>
						</div>
						<p>此上下文根据一个或多个事件属性的值，使用谓词表达式定义上下文分区成员资格，将事件分配给上下文分区。因此，每个事件根据谓词表达式的结果可以属于零个、一个或多个上下文分区。</p>
						<p>创建类别分段上下文的语法如下：</p>
						<pre class="synopsis">create context <span class="emphasis"><em>context_name</em></span>
  group [by] <span class="emphasis"><em>group_expression</em></span> as <span class="emphasis"><em>category_label</em></span>
  [, group [by] <span class="emphasis"><em>group_expression</em></span> as <span class="emphasis"><em>category_label</em></span>]
  [, ...]
  from <span class="emphasis"><em>stream_def</em></span>
    </pre>
						<p>
							您分配给上下文的<span class="emphasis"><em>context_name</em></span>可以是任何标识符。
						</p>
						<p>
							在上下文名称之后是用<code class="literal">group</code>关键字分隔的组列表。组列表后跟<code class="literal">from</code>关键字和流定义。
						</p>
						<p>
							<span class="emphasis"><em>group_expression</em></span>是一个对事件进行分类的表达式。每个组表达式后必须跟<code class="literal">as</code>关键字和一个类别标签，类别标签可以是任何标识符。
						</p>
						<p>组表达式是谓词表达式，应用于事件时必须返回布尔类型的true或false。对于给定事件，任何数量的组表达式都可能返回true，因此类别可以重叠。</p>
						<p>
							<span class="emphasis"><em>stream_def</em></span>是流定义，由事件类型名称组成，可选地后跟包含过滤器表达式的括号。如果提供过滤器表达式，则只有匹配该事件类型的提供的过滤器表达式的事件才会被上下文分区考虑。
						</p>
						<p>
							下一个语句创建一个上下文<code class="literal">CategoryByTemp</code>，该上下文考虑<code class="literal">SensorEvent</code>事件类型的<code class="literal">temperature</code>属性的值来选择要分配事件的上下文分区：
						</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context CategoryByTemp
  group temp &lt; 65 as cold,
  group temp between 65 and 85 as normal,
  group temp &gt; 85 as large
  from SensorEvent</pre>
						<p>以下语句简单地计算每个类别的事件数量，并输出类别标签和计数：</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CategoryByTemp select context.label, count(*) from SensorEvent</pre>
						<div class="sect3" lang="zh-CN">
							<div class="titlepage">
								<div>
									<div>
										<h4 class="title"><a id="context_def_category_builtin"></a>4.2.4.1. 内置上下文属性</h4>
									</div>
								</div>
							</div>
							<p>当您的语句引用类别分段上下文时，以下上下文属性可用：</p>
							<div class="table">
								<a id="d0e4797"></a>
								<p class="title">
									<b>表4.3. 类别分段上下文属性</b>
								</p>
								<div class="table-contents">
									<table summary="类别分段上下文属性" border="1">
										<colgroup>
											<col>
												<col>
										</colgroup>
										<thead>
											<tr>
												<th>名称</th>
												<th>描述</th>
											</tr>
										</thead>
										<tbody>
											<tr>
												<td><code class="literal">name</code></td>
												<td>字符串类型的上下文名称。</td>
											</tr>
											<tr>
												<td><code class="literal">id</code></td>
												<td>运行时分配给上下文分区的整数类型内部上下文分区ID。</td>
											</tr>
											<tr>
												<td><code class="literal">label</code></td>
												<td>类别标签是为每个组在<code class="literal">as</code>关键字后指定的字符串标识符值。
												</td>
											</tr>
										</tbody>
									</table>
								</div>
							</div>
							<br class="table-break">
								<p>例如，您可以选择上下文属性如下：</p> <pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CategoryByTemp
  select context.name, context.id, context.label from SensorEvent</pre>
						</div>
					</div>
					<div class="sect2" lang="zh-CN">
						<div class="titlepage">
							<div>
								<div>
									<h3 class="title"><a id="context_def_nonoverlapping"></a>4.2.5. 非重叠上下文</h3>
								</div>
							</div>
						</div>
						<p>您可以声明一个非重叠上下文，该上下文存在一次或以由开始条件和可选的结束条件控制的规则方式重复。上下文分区的数量始终为一或零：上下文分区不重叠。</p>
						<p>创建非重叠上下文的语法如下：</p>
						<pre class="synopsis">create context <span class="emphasis"><em>context_name</em></span>
  start (@now | <span class="emphasis"><em>start_condition</em></span>) 
  [ end <span class="emphasis"><em>end_condition</em></span> ]</pre>
						<p>
							您分配给上下文的<span class="emphasis"><em>context_name</em></span>可以是任何标识符。
						</p>
						<p>
							在上下文名称之后是<code class="literal">start</code>关键字，可以是<code class="literal">@now</code>或<span class="emphasis"><em>start_condition</em></span>。其后是可选的<code class="literal">end</code>关键字和<span class="emphasis"><em>end_condition</em></span>。
						</p>
						<p>
							开始条件和结束条件(如果指定)可以是事件过滤器、模式、crontab或时间段。开始和结束条件的语法在<a class="xref" href="context.html#context_def_condition" title="4.2.7. 上下文条件">第4.2.7节"上下文条件"</a>中描述。
						</p>
						<p>
							一旦开始条件发生，运行时不再观察开始条件，并开始观察结束条件(如果提供了结束条件)。一旦结束条件发生，运行时再次观察开始条件。如果您指定了<code class="literal">@now</code>而不是开始条件，运行时开始观察结束条件。如果没有结束条件，上下文分区保持活动状态且不会结束。
						</p>
						<p>
							如果您指定了事件过滤器作为开始条件，则该事件也计入引用该上下文的语句。如果您指定了模式作为开始条件，则构成模式匹配的事件也可以计入引用该上下文的语句，前提是同时指定了<code class="literal">@inclusive</code>和事件标签(见下文)。
						</p>
						<p>在上下文激活时，当您的应用程序创建使用该上下文的语句时，运行时检查开始和结束条件是否为crontab表达式。运行时评估开始和结束crontab表达式，并确定当前时间是否在开始和结束时间之间。如果当前时间在开始和结束时间之间，运行时分配上下文分区并等待观察结束时间。否则运行时等待观察开始时间，不分配上下文分区。</p>
						<p>
							可用的内置上下文属性与<a class="xref" href="context.html#context_def_overlapping_builtin" title="4.2.6.2. 内置上下文属性">第4.2.6.2节"内置上下文属性"</a>中描述的相同。
						</p>
						<p>
							下一个语句创建一个上下文<code class="literal">NineToFive</code>，该上下文声明一个每天从上午9点开始到下午5点结束的时间段：
						</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context NineToFive start (0, 9, *, *, *) end (0, 17, *, *, *)</pre>
						<p>以下语句输出上午9点至下午5点之间的超速违规，考虑速度大于等于100为违规：</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context NineToFive select * from TrafficEvent(speed &gt;= 100)</pre>
						<p>下面的示例演示了使用事件过滤器作为开始条件和模式作为结束条件。</p>
						<p>
							下一个语句创建一个上下文<code class="literal">PowerOutage</code>，当第一个<code class="literal">PowerOutageEvent</code>事件到达时开始，并在随后的<code class="literal">PowerOnEvent</code>到达5秒后结束：
						</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context PowerOutage start PowerOutageEvent end pattern [PowerOnEvent -&gt; timer:interval(5)]</pre>
						<p>以下语句输出停电期间以及电源恢复后5秒内的温度：</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context PowerOutage select * from TemperatureEvent</pre>
						<p>要仅在上下文分区结束时(终止、过期)输出最后一个值，请继续阅读输出速率限制的描述。</p>
						<p>
							下一个语句创建一个上下文<code class="literal">Every15Minutes</code>，该上下文立即开始并持续15分钟，在15分钟间隔结束时重复分配新的上下文分区：
						</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context Every15Minutes start @now end after 15 minutes</pre>
						<p>
							下一个示例声明了一个<code class="literal">AlwaysOn</code>上下文：它立即开始，除非应用程序使用API终止上下文分区，否则不会结束：
						</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context AlwaysOn start @now</pre>
						<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="tip">
							<h2>提示</h2>
							<p>
								带有<code class="literal">@now</code>的非重叠上下文始终开启：在任何给定时间点始终分配一个上下文分区。只有在指定<code class="literal">@now</code>时，才会在任何时间点始终存在上下文分区。
							</p>
						</div>
						<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="note">
							<h2>注意</h2>
							<p>如果您为上下文分区指定了事件过滤器或模式作为结束条件，并且引用该上下文的语句指定了匹配相同条件的事件过滤器或模式，请使用@Priority指示运行时是上下文管理优先还是语句评估优先(见下文配置优先级执行)。</p>
							<p>例如，如果您的上下文声明如下：</p>
							<pre xmlns="" class="">create context MyCtx start MyStartEvent end MyEndEvent</pre>
							<p>由上下文管理的语句如下：</p>
							<pre class="synopsis">context MyCtx select count(*) as cnt from MyEndEvent output when terminated</pre>
							<p>
								通过为create-context使用<code class="literal">@Priority(1)</code>和为计数语句使用<code class="literal">@Priority(0)</code>，计数语句不会计算最后一个<code class="literal">MyEndEvent</code>，因为上下文分区管理优先。
							</p>
							<p>
								通过为create-context使用<code class="literal">@Priority(0)</code>和为计数语句使用<code class="literal">@Priority(1)</code>，计数语句将计算最后一个<code class="literal">MyEndEvent</code>，因为语句评估优先。
							</p>
						</div>
					</div>
					<div class="sect2" lang="zh-CN">
						<div class="titlepage">
							<div>
								<div>
									<h3 class="title"><a id="context_def_overlapping"></a>4.2.6. 重叠上下文</h3>
								</div>
							</div>
						</div>
						<p>此上下文在启动条件发生时启动新的上下文分区，并在终止条件发生时终止一个或多个上下文分区(如果指定了终止条件)。因此，在任何时间点可以有多个重叠的上下文分区处于活动状态，且上下文分区可以重叠。</p>
						<p>创建重叠上下文的语法如下：</p>
						<pre class="synopsis">create context <span class="emphasis"><em>context_name</em></span>
  initiated [by] [distinct (<span class="emphasis"><em>distinct_value_expr [,...]</em></span>)] [@now and] <span class="emphasis"><em>initiating_condition</em></span>
  [ terminated [by] <span class="emphasis"><em>terminating_condition</em></span> ]</pre>
						<p>
							您分配给上下文的<span class="emphasis"><em>context_name</em></span>可以是任何标识符。
						</p>
						<p>
							在上下文名称之后是<code class="literal">initiated</code>关键字。在<code class="literal">initiated</code>关键字之后，您可以可选地指定<code class="literal">distinct</code>关键字，并在括号内列出一个或多个不同的值表达式。在<code class="literal">initiated</code>关键字之后，您还可以指定<code class="literal">@now and</code>，如下所述。
						</p>
						<p>
							在<code class="literal">initiated</code>关键字之后，您必须指定启动条件。您可以可选地使用<code class="literal">terminated</code>关键字后跟终止条件。如果未指定终止条件，每个上下文分区保持活动状态且不会终止。
						</p>
						<p>
							启动条件和终止条件(如果指定)可以是事件过滤器、模式、crontab或时间段。启动和终止条件的语法在<a class="xref" href="context.html#context_def_condition" title="4.2.7. 上下文条件">第4.2.7节"上下文条件"</a>中描述。
						</p>
						<p>
							如果您在启动条件之前指定了<code class="literal">@now and</code>，则运行时立即启动新的上下文分区。<code class="literal">@now</code>仅允许与指定模式、crontab或时间段的启动条件一起使用，不允许与事件过滤器一起使用。
						</p>
						<p>
							如果您为启动条件指定了事件过滤器，则启动新上下文分区的事件也计入引用该上下文的语句。如果您指定了模式以启动新的上下文分区，则构成模式匹配的事件也可以计入引用该上下文的语句，前提是同时指定了<code class="literal">@inclusive</code>和事件标签(见下文)。
						</p>
						<p>
							下一个语句创建一个上下文<code class="literal">CtxTrainEnter</code>，当火车进入车站时分配新的上下文分区，并在分配上下文分区5分钟后终止每个上下文分区：
						</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context CtxTrainEnter
  initiated by TrainEnterEvent as te
  terminated after 5 minutes</pre>
						<p>
							上面声明的上下文分配了流名称<code class="literal">te</code>。因此，可以通过指定<code class="literal">context.te.trainId</code>来访问启动事件的属性。
						</p>
						<p>
							以下语句检测火车进入车站(由<code class="literal">TrainEnterEvent</code>指示)，但在5分钟内未离开车站(由匹配的<code class="literal">TrainLeaveEvent</code>指示)：
						</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxTrainEnter
select t1 from pattern [
  t1=TrainEnterEvent(trainId = context.te.trainId) -&gt; timer:interval(5 min) and not TrainLeaveEvent(trainId = context.te.trainId)
  ]</pre>
						<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="tip">
							<h2>提示</h2>
							<p>每个事件(传入或插入)应用于每个上下文分区。您必须提供过滤器表达式以指示事件如何应用于上下文分区。</p>
							<p>
								上面的示例有<code class="literal">trainId = context.te.trainId</code>，表示事件的火车ID必须与特定上下文分区的启动事件的火车ID匹配。
							</p>
						</div>
						<p>
							由于启动新上下文分区的<code class="literal">TrainEnterEvent</code>也计入语句，模式的第一部分(<code class="literal">t1=TrainEnterEvent</code>)由该启动事件满足。
						</p>
						<p>
							下一个语句创建一个上下文<code class="literal">CtxEachMinute</code>，该上下文立即分配新的上下文分区，并且每1分钟分配一次，并在分配上下文分区1分钟后终止每个上下文分区：
						</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context CtxEachMinute
  initiated @now and pattern [every timer:interval(1 minute)]
  terminated after 1 minutes</pre>
						<p>
							上面的语句指定了<code class="literal">@now</code>，指示运行时立即分配新的上下文分区，以及在模式触发时分配。如果没有<code class="literal">@now</code>，运行时仅在1分钟后和之后的每分钟模式触发时分配新的上下文分区。
						</p>
						<p>以下语句平均温度，每分钟重新开始，并持续输出聚合值：</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxEachMinute select avg(temp) from SensorEvent</pre>
						<p>要仅在上下文分区结束时(终止、过期)输出最后一个值，请继续阅读输出速率限制的描述。</p>
						<p>通过不提供终止条件，您可以告诉运行时分配永远不会终止的上下文分区，例如：</p>
						<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context CtxTrainEnter initiated by TrainEnterEvent as te</pre>
						<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="note">
							<h2>注意</h2>
							<p>如果您为上下文分区指定了事件过滤器或模式作为终止条件，并且引用该上下文的语句指定了匹配相同条件的事件过滤器或模式，请使用@Priority指示运行时是上下文管理优先还是语句评估优先(见下文配置优先级执行)。有关更多信息，请参见上面的说明。</p>
						</div>
						<div class="sect3" lang="zh-CN">
							<div class="titlepage">
								<div>
									<div>
										<h4 class="title"><a id="context_def_overlapping_distinct"></a>4.2.6.1. 启动条件的唯一事件</h4>
									</div>
								</div>
							</div>
							<p>
								如果您的启动条件是过滤器上下文条件，您可以指定<code class="literal">distinct</code>关键字，后跟一个或多个唯一值表达式。关于键表达式的更多详细信息可以在<a class="xref" href="epl_clauses.html#epl-syntax-compositekey" title="5.2.13. 复合键和数组值作为键">第5.2.13节"复合键和数组值作为键"</a>中找到。
							</p>
							<p>以下示例EPL指定了一个上下文，该上下文为不同的订单ID值启动上下文分区，记住该订单ID直到上下文分区终止：</p>
							<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context OrderContext
  initiated by distinct(orderId) NewOrderEvent as newOrder 
  terminated by CloseOrderEvent(closeOrderId = newOrder.orderId)</pre>
							<p>
								运行时仅在给定<code class="literal">NewOrderEvent</code>的<code class="literal">orderId</code>值不存在上下文分区时分配新的上下文分区。当上下文分区在<code class="literal">CloseOrderEvent</code>到达时终止时，运行时忘记<code class="literal">orderId</code>，允许下一个具有相同<code class="literal">orderId</code>的<code class="literal">NewOrderEvent</code>事件分配新的上下文分区。
							</p>
							<p>请注意以下限制：</p>
							<div class="itemizedlist">
								<ul>
									<li>
										<p>
											<code class="literal">distinct</code>关键字要求启动条件是事件流(而不是crontab或模式等)，并且必须使用<code class="literal">as</code>关键字分配流名称。
										</p>
									</li>
									<li>
										<p>
											子查询、聚合和特殊的<code class="literal">prev</code>和<code class="literal">prior</code>函数不允许出现在唯一值表达式中。
										</p>
									</li>
								</ul>
							</div>
						</div>
						<div class="sect3" lang="zh-CN">
							<div class="titlepage">
								<div>
									<div>
										<h4 class="title"><a id="context_def_overlapping_builtin"></a>4.2.6.2. 内置上下文属性</h4>
									</div>
								</div>
							</div>
							<p>当您的语句引用上下文时，以下上下文属性可用：</p>
							<div class="table">
								<a id="d0e5180"></a>
								<p class="title">
									<b>表4.4. 上下文属性</b>
								</p>
								<div class="table-contents">
									<table summary="上下文属性" border="1">
										<colgroup>
											<col>
												<col>
										</colgroup>
										<thead>
											<tr>
												<th>名称</th>
												<th>描述</th>
											</tr>
										</thead>
										<tbody>
											<tr>
												<td><code class="literal">name</code></td>
												<td>字符串类型的上下文名称。</td>
											</tr>
											<tr>
												<td><code class="literal">startTime</code></td>
												<td>上下文分区的开始时间。</td>
											</tr>
											<tr>
												<td><code class="literal">endTime</code></td>
												<td>上下文分区的结束时间。此字段仅在可以从提供的crontab或时间段表达式计算时可用。请改用<code class="literal">current_timestamp</code>。
												</td>
											</tr>
										</tbody>
									</table>
								</div>
							</div>
							<br class="table-break">
								<p>例如，您可以选择上下文属性如下：</p> <pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context NineToFive 
select context.name, context.startTime, context.endTime from TrafficEvent(speed &gt;= 100)</pre>
								<p>以下语句查找相同火车ID的下一个火车离开事件，并选择几个上下文属性：</p> <pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxTrainEnter
select *, context.te.trainId, context.id, context.name
from TrainLeaveEvent(trainId = context.te.trainId)</pre>
						</div>
						<div class="sect2" lang="zh-CN">
							<div class="titlepage">
								<div>
									<div>
										<h3 class="title"><a id="context_def_condition"></a>4.2.7. 上下文条件</h3>
									</div>
								</div>
							</div>
							<p>上下文开始/启动和结束/终止条件用于重叠和非重叠上下文。可以指定任何组合的条件。</p>
							<div class="sect3" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h4 class="title"><a id="context_def_condition_filter"></a>4.2.7.1. 过滤器上下文条件</h4>
										</div>
									</div>
								</div>
								<p>定义启动/启动上下文分区或结束/终止上下文分区的流：</p>
								<pre class="synopsis">
    <span class="emphasis"><em>event_stream_name</em></span> [(<span class="emphasis"><em>filter_criteria</em></span>)] [as <span class="emphasis"><em>stream_name</em></span>]</pre>
								<p>
									<span class="emphasis"><em>event_stream_name</em></span>是事件类型的名称或由insert into语句填充的事件流的名称。<span class="emphasis"><em>filter_criteria</em></span>是可选的，由过滤事件流的事件的表达式列表组成，在事件流名称后的括号内。
								</p>
								<p>两个示例是：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 非重叠上下文，当MyStartEvent到达时开始，当MyEndEvent到达时结束
create context MyContext start MyStartEvent end MyEndEvent</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 重叠上下文，其中每个level大于零的MyEvent
// 启动一个新的上下文分区，10秒后终止
create context MyContext initiated MyEvent(level &gt; 0) terminated after 10 seconds</pre>
								<p>
									您可以通过在<code class="literal">as</code>关键字后提供流名称，并在结束条件的过滤条件中引用该流名称，来关联开始/启动和结束/终止流。
								</p>
								<p>两个关联开始/启动和结束/终止条件的示例是：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 非重叠上下文，当MyEvent到达时开始
// 并在匹配的MyEvent到达时结束(相同id)
create context MyContext 
start MyEvent as myevent
end MyEvent(id=myevent.id)</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 重叠上下文，其中每个MyInitEvent启动一个新的上下文分区 
// 当匹配的MyTermEvent到达时终止 
create context MyContext 
initiated by MyInitEvent as e1 
terminated by MyTermEvent(id=e1.id, level &lt;&gt; e1.level) as e2</pre>
								<p>
									当为过滤器指定流名称时，上下文内置属性携带流名称。例如(终止仅在<code class="literal">output when terminated</code>时输出)：
								</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context MyContext select context.e1, context.e1.propertyName, context.e2, context.e2.propertyName from SomeEvent</pre>
							</div>
							<div class="sect3" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h4 class="title"><a id="context_def_condition_pattern"></a>4.2.7.2. 模式上下文条件</h4>
										</div>
									</div>
								</div>
								<p>您可以定义一个模式来启动/启动上下文分区或结束/终止上下文分区：</p>
								<pre class="synopsis">pattern [<span class="emphasis"><em>pattern_expression</em></span>] [@inclusive] [as <span class="emphasis"><em>stream_name</em></span>]</pre>
								<p>
									<span class="emphasis"><em>pattern_expression</em></span>是<a class="xref" href="event_patterns.html" title="第7章. EPL参考：模式">第7章<i>EPL参考：模式</i></a>中的模式。
								</p>
								<p>
									在模式后指定<code class="literal">@inclusive</code>，使构成模式匹配的相同事件也计入与上下文关联的任何语句。您还必须为应包含在模式中的每个事件提供一个标签。
								</p>
								<p>示例是：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 非重叠上下文，当StartEventOne或StartEventTwo到达时开始
// 并在5秒后结束。
// 这里StartEventOne或StartEventTwo不计入任何
// 引用上下文的语句。
create context MyContext 
  start pattern [StartEventOne or StartEventTwo] 
  end after 5 seconds</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 同上。
// 这里StartEventOne或StartEventTwo计入
// 引用上下文的语句。
create context MyContext 
  start pattern [a=StartEventOne or b=StartEventTwo] @inclusive 
  end after 5 seconds</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 重叠上下文，其中每个不同的MyInitEvent启动一个新的上下文 
// 每个上下文分区在20秒后终止
// 使用@inclusive表示触发模式的相同MyInitEvent
// 也适用于与上下文关联的语句。
create context MyContext
  initiated by pattern [every-distinct(a.id, 20 sec) a=MyInitEvent]@inclusive
  terminated after 20 sec</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 重叠上下文，其中每个模式匹配启动一个新的上下文 
// 所有上下文分区在MyTermEvent到达时终止。
// 触发模式的MyInitEvent和MyOtherEvent本身不包含 
// 在与上下文关联的任何语句中。
create context MyContext
  initiated by pattern [every MyInitEvent -&gt; MyOtherEvent where timer:within(5)]
  terminated by MyTermEvent</pre>
								<p>您可以通过在模式中提供标签，并在结束条件的过滤条件中引用标签名称，来关联开始和结束流。</p>
								<p>关联开始和结束条件的示例是：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 非重叠上下文，当StartEventOne或StartEventTwo到达时开始
// 并在匹配的EndEventOne或EndEventTwo到达时结束
create context MyContext 
  start pattern [a=StartEventOne or b=StartEventTwo]
  end pattern [EndEventOne(id=a.id) or EndEventTwo(id=b.id)]</pre>
								<p>
									您可以通过在<code class="literal">as</code>关键字后提供流名称，并在结束条件的过滤条件中引用该流名称，来关联开始/启动和结束/终止模式。
								</p>
								<p>关联开始和结束条件并为模式匹配指定流名称的示例如下：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context MyContext 
  start pattern [a=StartEventOne or b=StartEventTwo] as startingPattern
  end pattern [c=EndEventOne(id=startingPattern.a.id) or d=EndEventTwo(id=startingPattern.b.id)] as endingPattern</pre>
								<p>
									当为模式指定流名称时，上下文内置属性携带流名称。例如(终止仅在<code class="literal">output when terminated</code>时输出)：
								</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context MyContext select context.startingPattern, context.startingPattern.a, context.startingPattern.a.propertyName, context.endingPattern, context.endingPattern.c, context.endingPattern.c.propertyName from SomeEvent</pre>
							</div>
							<div class="sect3" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h4 class="title"><a id="context_def_condition_crontab"></a>4.2.7.3. Crontab上下文条件</h4>
										</div>
									</div>
								</div>
								<p>
									Crontab表达式在<a class="xref" href="event_patterns.html#pattern-timer-at" title="7.6.4. Crontab (timer:at)">第7.6.4节"Crontab (timer:at)"</a>中描述。
								</p>
								<p>可以提供多个由逗号分隔的crontab表达式。当指定多个crontab时，运行时根据crontab确定最早的时间。</p>
								<p>示例是：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 非重叠上下文，每天上午9点到下午5点之间启动
// 在这些时间之外不启动：
create context NineToFive start (0, 9, *, *, *) end (0, 17, *, *, *)</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 重叠上下文，其中crontab每分钟启动一个新的上下文
// 每个上下文分区在10秒后终止：
create context MyContext initiated (*, *, *, *, *) terminated after 10 seconds</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 从上午8:00(见start)到上午9点(见end)和从上午10点(见start)到中午12点(见end)。
create context MyContext
  start (0, 8, *, *, *, *), (0, 10, *, *, *, *)
  end (0, 9, *, *, *, *), (0, 12, *, *, *, *)</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 周一到周五上午8点到11点，周六和周日从上午8点到晚上8点。
create context MyContext
  start (0, 8, *, *, *, *)
  end (0, 11, *, *, [1, 2, 3, 4, 5], *), (0, 20, *, *, [0, 6], *)</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 周一上午8点到10点，周二上午9点到10点
create context MyContext
  start (0, 8, *, *, 1, *), (0, 9, *, *, 2, *)
  end (0, 10, *, *, *)</pre>
							</div>
							<div class="sect3" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h4 class="title"><a id="context_def_condition_after"></a>4.2.7.4. 时间段上下文条件</h4>
										</div>
									</div>
								</div>
								<p>
									您可以指定运行时在条件触发前观察的时间段。时间段表达式在<a class="xref" href="epl_clauses.html#epl-syntax-time-periods" title="5.2.1. 指定时间段">第5.2.1节"指定时间段"</a>中描述。
								</p>
								<p>语法是：</p>
								<pre class="synopsis">after <span class="emphasis"><em>time_period_expression</em></span>
    </pre>
								<p>示例是：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 非重叠上下文，10秒后启动 
// 在启动1分钟后结束，然后再次在10秒后启动。
create context NonOverlap10SecFor1Min start after 10 seconds end after 1 minute</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 重叠上下文，每5秒启动一个新的上下文分区
// 每个上下文分区持续1分钟
create context Overlap5SecFor1Min initiated after 5 seconds terminated after 1 minute</pre>
							</div>
						</div>
						<div class="sect1" lang="zh-CN">
							<div class="titlepage">
								<div>
									<div>
										<h2 class="title"><a id="context_nesting"></a>4.3. 上下文嵌套</h2>
									</div>
								</div>
							</div>
							<p>嵌套上下文是由两个或多个上下文组成的上下文。</p>
							<p>创建嵌套上下文的语法如下：</p>
							<pre class="synopsis">create context <span class="emphasis"><em>context_name</em></span>
  context <span class="emphasis"><em>nested_context_name</em></span> [as] <span class="emphasis"><em>nested_context_definition</em></span> ,
  context <span class="emphasis"><em>nested_context_name</em></span> [as] <span class="emphasis"><em>nested_context_definition</em></span> [, ...]</pre>
							<p>
								您分配给上下文的<span class="emphasis"><em>context_name</em></span>可以是任何标识符。
							</p>
							<p>
								在上下文名称之后是用逗号分隔的嵌套上下文列表。对于每个嵌套上下文，指定<code class="literal">context</code>关键字，后跟嵌套上下文名称和嵌套上下文声明。<a class="xref" href="context.html#context_decl" title="4.2. 上下文声明">第4.2节"上下文声明"</a>中概述的任何上下文声明都允许用于嵌套上下文。嵌套上下文声明的顺序很重要，如下所述。嵌套上下文名称仅在内置属性方面有意义，语句不能分配给嵌套上下文名称。
							</p>
							<p>
								下一个语句创建一个嵌套上下文<code class="literal">NineToFiveSegmented</code>，该上下文在上午9点到下午5点之间，为每个客户ID分配一个新的上下文分区：
							</p>
							<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context NineToFiveSegmented
  context NineToFive start (0, 9, *, *, *) end (0, 17, *, *, *),
  context SegmentedByCustomer partition by custId from BankTxn</pre>
							<p>以下语句引用嵌套上下文，计算每个客户在上午9点到下午5点之间的每个账户的总取款金额：</p>
							<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context NineToFiveSegmented
select custId, account, sum(amount) from BankTxn group by account</pre>
							<p>EPL将嵌套上下文实现为上下文树：首先声明的上下文控制其后声明的上下文的生命周期。因此，在上述示例中，在上午9点到下午5点之外，运行时没有与银行交易或客户ID相关的内存，也不消耗资源。</p>
							<p>当组合分段上下文时，嵌套上下文的上下文分区集实际上是嵌套分段上下文的分区集的笛卡尔积。</p>
							<p>当将时间上下文与其他上下文组合时，由于时间上下文可能重叠并可能终止，重要的是要理解时间上下文控制子上下文(其后声明的上下文)的生命周期。嵌套上下文中上下文的声明顺序因此可以改变资源使用和输出结果。</p>
							<p>下一个语句创建一个上下文，该上下文仅在火车进入车站时为PassengerScanEvent事件的标签ID的每个哈希分配上下文分区，并在5分钟后终止所有上下文分区：</p>
							<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context CtxNestedTrainEnter
  context InitCtx initiated by TrainEnterEvent as te terminated after 5 minutes,
  context HashCtx coalesce by consistent_hash_crc32(tagId) from PassengerScanEvent
    granularity 16 preallocate</pre>
							<p>
								在上面的示例中，运行时在TrainEnterEvent到达之前不会开始跟踪PassengerScanEvent事件或哈希代码或分配上下文分区。因为<code class="literal">HashCtx</code>声明了<code class="literal">preallocate</code>，运行时在TrainEnterEvent到达时立即分配16个分区。如果<code class="literal">HashCtx</code>没有声明<code class="literal">preallocate</code>，运行时将等待PassengerScanEvent事件到达，然后才分配分区，随着更多PassengerScanEvent事件到达，根据tagId值最多分配16个分区。
							</p>
							<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="tip">
								<h2>提示</h2>
								<p>将嵌套上下文视为父子关系，父级首先声明，子级随后列出。</p>
								<p>嵌套上下文不是OR运算符，也不是交集。切换父级和子级会改变行为。</p>
							</div>
							<div class="sect2" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h3 class="title"><a id="context_nesting_walkthru"></a>4.3.1. 嵌套上下文示例演练</h3>
										</div>
									</div>
								</div>
								<p>本节声明了一个带有嵌套非重叠上下文的嵌套上下文，并通过特定场景演练，帮助您更好地理解嵌套上下文生命周期。</p>
								<p>
									假设事件类型<code class="literal">AStart</code>、<code class="literal">AEnd</code>、<code class="literal">BStart</code>、<code class="literal">BEnd</code>和<code class="literal">C</code>。以下EPL计算在<code class="literal">AStart</code>和<code class="literal">AEnd</code>以及<code class="literal">BStart</code>和<code class="literal">BEnd</code>跨度内发生的<code class="literal">C</code>事件，其中<code class="literal">AStart</code>-to-<code class="literal">AEnd</code>的跨度必须包含<code class="literal">BStart</code>-to-<code class="literal">BEnd</code>的跨度：
								</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context CtxSampleNestedContext
  context SpanA start AStart end AEnd,
  context SpanB start BStart end BEnd</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxSampleNestedContext select count(*) from C</pre>
								<p>
									在创建上述语句后，运行时开始仅查找<code class="literal">AStart</code>事件，尚不查找<code class="literal">AEnd</code>、<code class="literal">BStart</code>、<code class="literal">BEnd</code>或<code class="literal">C</code>事件。
								</p>
								<p>
									在场景中，假设下一个到达的是<code class="literal">AStart</code>事件。这在逻辑上是<code class="literal">SpanA</code>生命周期(也称为会话、间隔)的开始：
								</p>
								<div class="itemizedlist">
									<ul>
										<li>
											<p>
												运行时停止查找<code class="literal">AStart</code>事件。
											</p>
										</li>
										<li>
											<p>
												运行时开始查找<code class="literal">AEnd</code>事件，因为这将意味着当前<code class="literal">SpanA</code>生命周期的结束。
											</p>
										</li>
										<li>
											<p>
												运行时开始查找<code class="literal">BStart</code>事件，以检测<code class="literal">SpanB</code>生命周期的开始。
											</p>
										</li>
									</ul>
								</div>
								<p>
									在场景中，假设下一个到达的是<code class="literal">BStart</code>事件。这在逻辑上是<code class="literal">SpanB</code>生命周期的开始：
								</p>
								<div class="itemizedlist">
									<ul>
										<li>
											<p>
												运行时停止查找进一步的<code class="literal">BStart</code>事件。
											</p>
										</li>
										<li>
											<p>
												运行时开始查找<code class="literal">BEnd</code>事件，因为这将意味着当前<code class="literal">SpanB</code>生命周期的结束。
											</p>
										</li>
										<li>
											<p>
												运行时继续查找<code class="literal">AEnd</code>事件，因为这将意味着当前<code class="literal">SpanA</code>生命周期的结束。
											</p>
										</li>
										<li>
											<p>
												运行时开始查找<code class="literal">C</code>事件，并开始计算每个到达的<code class="literal">C</code>。
											</p>
										</li>
									</ul>
								</div>
								<p>
									在场景中，假设下一个到达的是<code class="literal">BEnd</code>事件。这在逻辑上是<code class="literal">SpanB</code>生命周期的结束：
								</p>
								<div class="itemizedlist">
									<ul>
										<li>
											<p>
												运行时停止查找<code class="literal">BEnd</code>事件。
											</p>
										</li>
										<li>
											<p>
												运行时停止查找<code class="literal">C</code>事件并停止计数。
											</p>
										</li>
										<li>
											<p>
												运行时开始查找<code class="literal">BStart</code>事件，因为这将意味着另一个<code class="literal">SpanB</code>生命周期的开始。
											</p>
										</li>
									</ul>
								</div>
								<p>
									在场景中，假设下一个到达的是<code class="literal">AEnd</code>事件。这在逻辑上是<code class="literal">SpanA</code>生命周期的结束：
								</p>
								<div class="itemizedlist">
									<ul>
										<li>
											<p>
												运行时停止查找<code class="literal">AEnd</code>事件。
											</p>
										</li>
										<li>
											<p>
												运行时停止查找<code class="literal">BStart</code>事件。
											</p>
										</li>
										<li>
											<p>
												运行时开始查找<code class="literal">AStart</code>事件，因为这将意味着另一个<code class="literal">SpanA</code>生命周期的开始。
											</p>
										</li>
									</ul>
								</div>
								<p>
									在上述场景中，<code class="literal">AEnd</code>到达后，运行时回到与最初创建语句后相同的状态。
								</p>
								<p>如果您的用例需要逻辑OR关系，请考虑为开始条件使用模式，例如以下(与上述不等价)：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context CtxSampleNestedContext 
  start pattern[every a=AStart or every a=BStart] as mypattern 
  end pattern[every AEnd or every BEnd]</pre>
							</div>
							<div class="sect2" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h3 class="title"><a id="context_nesting_builtin"></a>4.3.2. 内置嵌套上下文属性</h3>
										</div>
									</div>
								</div>
								<p>
									所有嵌套上下文的上下文属性都可供使用。指定<code class="literal">context.</code><span class="emphasis"><em>nested_context_name</em></span><code class="literal">.</code><span class="emphasis"><em>property_name</em></span>，或者如果嵌套上下文声明提供了流名称或模式标签，则指定<code class="literal">context.</code><span class="emphasis"><em>nested_context_name</em></span><code class="literal">.</code><span class="emphasis"><em>stream_name</em></span><code class="literal">.</code><span class="emphasis"><em>property_name</em></span>。
								</p>
								<p>
									例如，考虑之前声明的<code class="literal">CtxNestedTrainEnter</code>上下文。以下语句选择了一些上下文属性：
								</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxNestedTrainEnter
select context.InitCtx.te.trainId, context.HashCtx.id,
  tagId, count(*) from PassengerScanEvent group by tagId</pre>
								<p>
									在第二个示例中，考虑之前声明的<code class="literal">NineToFiveSegmented</code>上下文。以下语句选择了一些上下文属性：
								</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context NineToFiveSegmented
select context.NineToFive.startTime, context.SegmentedByCustomer.key1 from BankTxn</pre>
								<p>当您的语句引用嵌套上下文时，以下上下文属性可用：</p>
								<div class="table">
									<a id="d0e5704"></a>
									<p class="title">
										<b>表4.5. 嵌套上下文属性</b>
									</p>
									<div class="table-contents">
										<table summary="嵌套上下文属性" border="1">
											<colgroup>
												<col>
													<col>
											</colgroup>
											<thead>
												<tr>
													<th>名称</th>
													<th>描述</th>
												</tr>
											</thead>
											<tbody>
												<tr>
													<td><code class="literal">name</code></td>
													<td>字符串类型的上下文名称。</td>
												</tr>
												<tr>
													<td><code class="literal">id</code></td>
													<td>运行时分配给上下文分区的整数类型内部上下文分区ID。</td>
												</tr>
											</tbody>
										</table>
									</div>
								</div>
								<br class="table-break">
									<p>此示例选择嵌套上下文名称和上下文分区ID：</p> <pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context NineToFiveSegmented select context.name, context.id from BankTxn</pre>
							</div>
							<div class="sect1" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h2 class="title"><a id="context_other"></a>4.4. 无上下文声明的分区</h2>
										</div>
									</div>
								</div>
								<p>您不需要声明上下文来单独分区数据窗口、聚合值或模式本身。您可以根据需要混合使用分区。</p>
								<p>下表概述了EPL支持的其他分区语法：</p>
								<div class="table">
									<a id="d0e5740"></a>
									<p class="title">
										<b>表4.6. EPL中不使用上下文声明的分区</b>
									</p>
									<div class="table-contents">
										<table summary="EPL中不使用上下文声明的分区" border="1">
											<colgroup>
												<col>
													<col>
														<col>
											</colgroup>
											<thead>
												<tr>
													<th>分区类型</th>
													<th>描述</th>
													<th>示例</th>
												</tr>
											</thead>
											<tbody>
												<tr>
													<td>分组数据窗口</td>
													<td>
														<p>在数据窗口级别分区，仅适用于附加的数据窗口。</p>
														<p>
															语法：<code class="literal">#groupwin(...)</code>
														</p>
													</td>
													<td><pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 每个客户2个事件的长度窗口
select * from
  BankTxn#groupwin(custId)#length(2)</pre></td>
												</tr>
												<tr>
													<td>分组聚合</td>
													<td>
														<p>在聚合级别分区，仅适用于任何聚合。</p>
														<p>
															语法：<code class="literal">group by ....</code>
														</p>
													</td>
													<td><pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select avg(price), window(*)
  from BankTxn group by custId</pre></td>
												</tr>
												<tr>
													<td>模式</td>
													<td>
														<p>分区模式子表达式。</p>
														<p>
															语法：<code class="literal">every</code>或<code class="literal">every-distinct</code>
														</p>
													</td>
													<td><pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select * from pattern [
  every a=BankTxn -&gt; BankTxn(custId = a.custId)...]</pre></td>
												</tr>
												<tr>
													<td>匹配识别</td>
													<td>
														<p>分区匹配识别模式。</p>
														<p>
															语法：<code class="literal">partition by</code>
														</p>
													</td>
													<td><pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select * from match_recognize 
  ... partition by custId</pre></td>
												</tr>
												<tr>
													<td>连接和子查询</td>
													<td>
														<p>分区连接和子查询。</p>
														<p>
															语法：<code class="literal">where ...</code>
														</p>
													</td>
													<td><pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select * from ... where a.custId = b.custId</pre></td>
												</tr>
											</tbody>
										</table>
									</div>
								</div>
								<br class="table-break">
							</div>
							<div class="sect1" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h2 class="title"><a id="context_outputinitiated"></a>4.5. 当上下文分区启动(非重叠上下文)或初始化(重叠上下文)时输出</h2>
										</div>
									</div>
								</div>
								<p>
									EPL语句中的<code class="literal">from</code>子句是可选的，您可以简单地选择相关的上下文属性。相关章节的链接是<a class="xref" href="context.html#context_def_keyed_builtin" title="4.2.2.7. 内置上下文属性">第4.2.2.7节"内置上下文属性"</a>、<a class="xref" href="context.html#context_def_hashed_builtin" title="4.2.3.3. 内置上下文属性">第4.2.3.3节"内置上下文属性"</a>、<a class="xref" href="context.html#context_def_category_builtin" title="4.2.4.1. 内置上下文属性">第4.2.4.1节"内置上下文属性"</a>、<a class="xref" href="context.html#context_def_overlapping_builtin" title="4.2.6.2. 内置上下文属性">第4.2.6.2节"内置上下文属性"</a>和<a class="xref" href="context.html#context_nesting_builtin" title="4.3.2. 内置嵌套上下文属性">第4.3.2节"内置嵌套上下文属性"</a>。
								</p>
								<p>
									以下示例<code class="literal">CtxPerOrder</code>上下文为每个<code class="literal">OrderEvent</code>初始化一个新的上下文分区，每个上下文分区在5分钟后过期：
								</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context CtxPerOrderFiveMinutes
initiated by OrderEvent as orderEvent
terminated after 5 minutes</pre>
								<p>
									当运行时由于<code class="literal">OrderEvent</code>到达而初始化上下文分区时，此EPL触发：
								</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxPerOrderFiveMinutes select context.orderEvent as orderEvent</pre>
								<p>
									使用<code class="literal">insert into</code>触发其他活动。使用fire-and-forget API查询上下文分区。示例可以在<a class="xref" href="apiruntime.html#apiruntime-fireandforget-fromisoptional" title="16.7.4. From子句是可选的">第16.7.4节"From子句是可选的"</a>中找到。使用上述EPL的<code class="literal">EPStatement</code>实例上的<code class="literal">iterator</code> API迭代上下文分区信息。更多信息可以在<a class="xref" href="apiruntime.html#apiruntime-statement-iterators" title="16.5.4. 使用迭代器">第16.5.4节"使用迭代器"</a>中找到。
								</p>
							</div>
							<div class="sect1" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h2 class="title"><a id="context_outputterminated"></a>4.6. 当上下文分区结束(非重叠上下文)或终止(重叠上下文)时输出</h2>
										</div>
									</div>
								</div>
								<p>
									您可以使用输出速率限制，使用<code class="literal">output when terminated</code>在上下文分区结束或终止时触发输出。这个概念在<a class="xref" href="processingmodel.html#processingmodel_basicpartitionedandoutputlimited" title="2.13. 基本分区和输出速率限制语句">第2.13节"基本分区和输出速率限制语句"</a>中向您介绍。有关输出速率限制的更多信息，请参阅<a class="xref" href="epl_clauses.html#epl-output-rate" title="5.7. 稳定和控制输出：输出子句">第5.7节"稳定和控制输出：输出子句"</a>。
								</p>
								<p>
									上下文<code class="literal">CtxEachMinute</code>每1分钟初始化一个新的上下文分区，每个上下文分区在5分钟后过期：
								</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context CtxEachMinute
initiated by pattern [every timer:interval(1 min)]
terminated after 5 minutes</pre>
								<p>
									EPL语句中的<code class="literal">from</code>子句是可选的，您可以简单地选择相关的上下文属性并使用<code class="literal">output when terminated</code>：
								</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxEachMinute select current_timestamp as endtime, context.id as contextId output when terminated</pre>
								<p>以下语句计算持续的平均温度，但仅在5分钟后上下文分区结束时输出平均温度的最后一个值，以及上下文分区ID和当前运行时时间：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxEachMinute
select current_timestamp as endtime, context.id, avg(temp) from SensorEvent output last when terminated</pre>
								<p>
									<code class="literal">when terminated</code>语法可以与其他输出速率结合使用。
								</p>
								<p>下一个示例每分钟输出一次，并在上下文分区结束时输出：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxEachMinute
select context.id, avg(temp) from SensorEvent output last every 1 minute and when terminated</pre>
								<p>如果上下文分区的结束/终止条件是事件或模式，则上下文属性包含模式中标记事件或结束/终止上下文分区的单个事件的信息。</p>
								<p>
									例如，考虑以下上下文，其中运行时为每个到达的<code class="literal">MyStartEvent</code>事件初始化一个新的上下文分区，并在匹配的<code class="literal">MyEndEvent</code>到达时终止上下文分区：
								</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context CtxSample
initiated by MyStartEvent as startevent
terminated by MyEndEvent(id = startevent.id) as endevent</pre>
								<p>以下语句输出初始化和终止事件的id属性，仅在上下文分区结束时输出：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxSample 
select context.startevent.id, context.endevent.id, count(*) from MyEvent
output last when terminated</pre>
								<p>
									您可以另外指定一个终止表达式，运行时在上下文分区终止时评估该表达式。仅当终止表达式评估为true时才会输出。表达式可以引用<a class="xref" href="epl_clauses.html#epl-output-expression" title="5.7.1.1. 使用表达式控制输出">第5.7.1.1节"使用表达式控制输出"</a>中描述的内置属性。语法如下：
								</p>
								<pre class="synopsis">...output when terminated and <span class="emphasis"><em>termination_expression</em></span>
    </pre>
								<p>下一个示例语句在上下文分区结束时输出，但仅在至少有2个事件可供输出时：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxEachMinute
select * from SensorEvent output when terminated and count_insert &gt;= 2</pre>
								<p>
									最后一个示例EPL在上下文分区结束时输出，并将变量<code class="literal">myvar</code>设置为新值：
								</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context CtxEachMinute
select * from SensorEvent output when terminated then set myvar=3</pre>
							</div>
							<div class="sect1" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h2 class="title"><a id="context_named_windows"></a>4.7. 上下文和命名窗口</h2>
										</div>
									</div>
								</div>
								<p>命名窗口是全局可见的数据窗口，可以被多个语句引用。您可以在声明上下文的语句中引用命名窗口，无需特殊考虑，但on-action语句除外(后者必须引用与命名窗口关联的相同上下文)。</p>
								<p>您还可以创建命名窗口并为命名窗口声明上下文。在这种情况下，运行时实际上管理单独的命名窗口，每个上下文分区一个。</p>
								<p>例如，考虑之前显示的上午9点到下午5点的非重叠上下文：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context NineToFive start (0, 9, *, *, *) end (0, 17, *, *, *)</pre>
								<p>您可以创建一个仅在上午9点到下午5点之间存在的命名窗口：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context NineToFive create window SpeedingEvents1Hour#time(30 min) as TrafficEvent</pre>
								<p>您可以插入到命名窗口中：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context NineToFive on TrafficEvent(speed &gt; 100) merge SpeedingEvents1Hour insert select *</pre>
								<p>任何on-merge、on-select、on-update和on-delete语句必须声明相同的上下文，以便对相同分区的命名窗口或表进行操作。</p>
								<p>以下不是有效的语句，因为它没有声明与命名窗口相同的上下文：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 必须为on-trigger语句声明相同的上下文
on TruncateEvent delete from SpeedingEvents1Hour</pre>
								<p>以下是有效的：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context NineToFive on TruncateEvent delete from SpeedingEvents1Hour</pre>
								<p>对于需要指定事件类型的上下文声明，例如哈希分段上下文和键分段上下文，请提供命名窗口的基础事件类型。</p>
								<p>以下示例语句为命名窗口定义类型，声明上下文并将命名窗口关联到上下文：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create schema ScoreCycle (userId string, keyword string, productId string, score long)</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context HashByUserCtx as 
  coalesce by consistent_hash_crc32(userId) from ScoreCycle granularity 64</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context HashByUserCtx create window ScoreCycleWindow#unique(productId, keyword) as ScoreCycle</pre>
								<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="note">
									<h2>注意</h2>
									<p>使用on-merge将事件插入到特定分区。</p>
									<p>
										<code class="literal">Insert Into</code>产生一个对所有分区可见的事件。
									</p>
								</div>
							</div>
							<div class="sect1" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h2 class="title"><a id="context_tables"></a>4.8. 上下文和表</h2>
										</div>
									</div>
								</div>
								<p>表是按主键组织行的全局可见数据结构，可以被多个语句引用。您可以在声明上下文的语句中引用表，无需特殊考虑，但on-action语句除外(后者必须引用与表关联的相同上下文)。</p>
								<p>您还可以创建表并为表声明上下文。在这种情况下，运行时实际上管理单独的表，每个上下文分区一个。</p>
								<p>例如，考虑之前显示的上午9点到下午5点的非重叠上下文：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context NineToFive start (0, 9, *, *, *) end (0, 17, *, *, *)</pre>
								<p>您可以创建一个仅在上午9点到下午5点之间存在的表：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context NineToFive create table AverageSpeedTable (
  carId string primary key, 
  avgSpeed avg(double))</pre>
								<p>只有在聚合语句声明相同上下文时，才能聚合到表中：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">// 声明与表相同的上下文
context NineToFive into table AverageSpeedTable
select avg(speed) as avgSpeed
from TrafficEvent
group by carId</pre>
								<p>当您为表声明上下文时，任何select、on-merge、on-select、on-update和on-delete语句以及查询表的子查询语句必须声明相同的上下文。</p>
								<p>例如，此EPL截断AverageSpeedTable：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context NineToFive on TruncateEvent delete from AverageSpeedTable</pre>
								<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="note">
									<h2>注意</h2>
									<p>使用on-merge或into-table将事件插入到特定分区。</p>
									<p>
										<code class="literal">Insert Into</code>产生一个对所有分区可见的事件。
									</p>
								</div>
							</div>
							<div class="sect1" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h2 class="title"><a id="context_variables"></a>4.9. 上下文和变量</h2>
										</div>
									</div>
								</div>
								<p>变量是可用于所有语句的标量、对象或事件值。变量可以是全局变量或上下文变量。</p>
								<p>全局变量的值对所有上下文分区都是相同的。以下示例声明了一个全局阈值变量：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create variable integer var_global_threshold = 100</pre>
								<p>对于上下文变量，每个上下文分区都有一个变量值。以下示例声明了一个上下文和一个上下文变量：</p>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create context ParkingLotContext initiated by CarArrivalEvent as cae terminated by CarDepartureEvent(lot = cae.lot)</pre>
								<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">context ParkingLotContext create variable integer var_parkinglot_threshold = 100</pre>
								<p>
									变量<code class="literal">var_parkinglot_threshold</code>是一个上下文变量。每个上下文分区可以有自己的变量值。
								</p>
								<p>
									有关变量的更多信息，请参阅<a class="xref" href="epl_clauses.html#variables_overview" title="5.17. 变量和常量">第5.17节"变量和常量"</a>。
								</p>
								<p>上下文变量只能在与相同上下文关联的语句中使用。</p>
							</div>
							<div class="sect1" lang="zh-CN">
								<div class="titlepage">
									<div>
										<div>
											<h2 class="title"><a id="context_selection"></a>4.10. 对特定上下文分区的操作</h2>
										</div>
									</div>
								</div>
								<p>
									读取和管理内容分区本身的API在<a class="xref" href="apiruntime.html#apiruntime-contextpartitionadmin" title="16.17. 上下文分区管理">第16.17节"上下文分区管理"</a>中。
								</p>
								<p>选择特定的上下文分区并查询上下文分区状态对于以下情况非常有用：</p>
								<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="orderedlist">
									<ol>
										<li>
											<p>
												迭代特定的上下文分区或特定的上下文分区集合。语句迭代在<a class="xref" href="apiruntime.html#apiruntime-statement-iterators" title="16.5.4. 使用迭代器">第16.5.4节"使用迭代器"</a>中描述。
											</p>
										</li>
										<li>
											<p>
												对特定的上下文分区执行即发即弃(按需)查询。即发即弃查询在<a class="xref" href="apiruntime.html#apiruntime-fireandforget" title="16.7. 使用EPFireAndForgetService执行即发即弃查询">第16.7节"使用EPFireAndForgetService执行即发即弃查询"</a>中描述。
											</p>
										</li>
									</ol>
								</div>
								<p>
									运行时提供了API来识别、过滤和选择上下文分区以进行语句迭代和即发即弃查询。这些API在<a class="xref" href="apiruntime.html#apiruntime-contextpartitionselection" title="16.16. 上下文分区选择">第16.16节"上下文分区选择"</a>中有详细描述。
								</p>
								<p>
									对于语句迭代，您的应用程序可以向<code class="literal">EPStatement</code>上的<code class="literal">iterate</code>和<code class="literal">safeIterate</code>方法提供上下文选择器对象。如果您的代码不提供上下文选择器，迭代将考虑所有上下文分区。在迭代时，运行时获取当前的上下文分区集合并分别迭代每个分区。如果您的语句有order-by子句，order-by子句在上下文分区内排序，而不是跨分区排序。
								</p>
								<p>
									对于即发即弃查询，您的应用程序可以向<code class="literal">EPFireAndForgetService</code>上的<code class="literal">executeQuery</code>方法和<code class="literal">EPFireAndForgetPreparedQuery</code>上的<code class="literal">execute</code>方法提供上下文选择器对象。如果您的代码不提供上下文选择器，即发即弃查询将考虑所有上下文分区。在执行即发即弃查询时，运行时获取当前的上下文分区集合并分别查询每个分区。如果即发即弃查询有order-by子句，order-by子句在上下文分区内排序，而不是跨分区排序。
								</p>
							</div>
						</div>
						<ul xmlns:d="http://docbook.org/ns/docbook" class="docnav">
							<li class="previous"><a accesskey="p" href="event_representation.html"><strong>上一页</strong>第3章 事件表示</a></li>
							<li class="up"><a accesskey="u" href="#"><strong>返回顶部</strong></a></li>
							<li class="home"><a accesskey="h" href="index.html"><strong>首页</strong></a></li>
							<li class="next"><a accesskey="n" href="epl_clauses.html"><strong>下一页</strong>第5章 EPL参考：子句</a></li>
						</ul>
</body>

</html>